#!/usr/bin/env python
# -*- coding: utf-8 -*
'''
PySoQt app
Created on 2010-06-15

@author: apito
'''
import os
import sys
from PyQt4 import QtGui
from PyQt4 import QtCore
from Socjum import Socjum
import time
import hashlib
import urllib
import tempfile
import PySoQtWin
__version__='0.3.0'
reload(sys)
sys.setdefaultencoding('utf-8')
			
class Win(QtGui.QMainWindow):
	
	def _message(self, text):
		u'''Wyświetla komunikaty w pasuk statusu okna'''
		message = '%s - %s' % (time.strftime("%H:%M:%S",time.localtime()), text)
		self.ui.statusBar.showMessage(message)
	def login(self):
		user = str(self.ui.loginLE.text())#Pobranie loginu z pola
		if len(user) < 1:
			self._message(u"Nie podano loginu.")
			return
		else:
			password = str(self.ui.passwordLE.text())#Pobranie hasła z pola 
			if len(password)<1:
				self._message(u"Nie podano hasła")
				return
			else:
				self._message(u'Logowanie..')
				log = socjum.login(user,password)
				print log
				if log is not None:
					self._message(log)
				else:
					self._ONLINE = True
					self.ui.hostCB.clear()
					self.ui.hostCB.addItems(socjum.Hosts) ##dodanie listy hostów społeczności użytkownika
					self.ui.loginGB.hide()
					self._message(u"zalogowano użytkownika %s"%user)
					self.ui.logoutTB.setText(u"Wyloguj %s" % user)
					self.Albums=socjum.Galeria(socjum.Hosts)#utworzenie obiektu galerii i pobieranie informacji	
					self.progressBarTimer = QtCore.QTimer()
					self.progressBarTimer.connect(self.progressBarTimer, QtCore.SIGNAL('timeout()'), self.ui.progressBox.check)
					self.progressBarTimer.start(50)
					self.ui.hostCB.connect(self.ui.hostCB, QtCore.SIGNAL('activated(int)'), self.showAlbums)
					self.ui.albumCB.connect(self.ui.albumCB, QtCore.SIGNAL('currentIndexChanged(int)'),self.showAlbumInfo)
					showAlbumsTimer = QtCore.QTimer()		
					showAlbumsTimer.singleShot(7000, self.showAlbums)
					
	def logout(self):
		if self._ONLINE:
			self.Albums.stop()
			log =socjum.logout()
			if log == 1:
				self._message(u"Wylogowano")
				self.ui.loginGB.show()
				self._ONLINE = False
				self.ui.hostCB.clear()
				self.ui.albumCB.clear()
				self.ui.albumAuthorL.clear()
				self.ui.albumPhotosL.clear()
				self.ui.albumThumbnailL.clear()
				return True
			else:
				self._message(u'Błąd wylogowania')
				return False
		else:
			return True
	def zamknij(self):
		return self.logout()
	
	def showAlbums(self, force=''):
		if self.ui.hostCB.count()==0:
			print u'Brak albumów'
			return
		host=str(self.ui.hostCB.currentText())
		self.ui.albumCB.clear()
		try:
			print "Sprawdzanie czy istnieją albmumy dla ", host
			albums = self.Albums.Albums[host]
			if force=='force':
				raise KeyError #przeładowanie informacji o albumie
		except KeyError:
			if host != '':
				self.Albums.Albums[host]= {} #czyszczenie informacji dla danego hosta
				self.Albums.getAlbums(host)
				albums = self.Albums.Albums[host]
		for album in albums:
			self.ui.albumCB.addItem(albums[album]['title'], album)
	def reloadAlbums(self):
		self.showAlbums(force='force')
		
	def showAlbumInfo(self):
		if self.ui.albumType.currentIndex() !=0:
			self._message(u"Nie odświeżono informacji o albumie. Zakładasz nowy album.")
			return
		album = self.ui.albumCB.itemData(self.ui.albumCB.currentIndex()).toString()
		album=str(album)
		host=self.ui.hostCB.currentText()
		host=str(host)
		if self.ui.albumCB.count() == 0:
			self._message(u'Brak albumów.')
			return
		self.ui.albumAuthorL.setText(self.Albums.Albums[host][album]['author'])
		self.ui.albumPhotosL.setText(self.Albums.Albums[host][album]['photos'])
		self.ui.albumDateL.setText(self.Albums.Albums[host][album]['date'])
		pixmap =self.thumbPixmap(self.Albums.Albums[host][album]['thumbnail'])
		self.ui.albumThumbnailL.setPixmap(pixmap)
		
		if self.Albums.Albums[host][album]['add'] ==1:
			self.ui.sendPhotosPB.setDisabled(False)
			self.ui.sendPhotosPB.setToolTip(u'Wyślij zdjęcia do aktualnie wybranego albumu.')
		else:
			self.ui.sendPhotosPB.setDisabled(True)
			self.ui.sendPhotosPB.setToolTip(u'Nie możesz dodawać zdjęć do tego albumu.')
		self._message(u'Wyświetlono informacje o albumie %s'%self.ui.albumCB.currentText())
	def checkAlbumType(self,tabIndex):
		'''Sprawdza czy dodajemy do istniejącego czy nowego albumu
		wykorzystuje sygnał z nazwą aktualnego taba'''
		if tabIndex == 1:
			self.ui.sendPhotosPB.setEnabled(True)
			self.ui.sendPhotosPB.setToolTip(u'Utwórz nowy album i wyślij zdjęcia')
		elif tabIndex ==0:
			self.showAlbumInfo()

	def getFiles(self):
		files = QtGui.QFileDialog.getOpenFileNames(self,
			u"Wybierz zdjęcia", QtCore.QDir.homePath(),
			u"Pliki obrazów ( *.jpg *.jpeg *.JPG *.JPEG  *.png *.PNG *.GIF *.gif *.tiff *.TIFF) ;; Wszystkie pliki (*.*)")
		if files:	
			self.ui.photosListBox.addItems(files) #add fotos to list
		else:
			self._message(u'Nie wybrano zdjęć')
			
	def deleteSelectedFiles(self):
		'''Usuwa zaznaczone pliki z listy wysyłki'''
		for item in self.ui.photosListBox.selectedItems():
			row = self.ui.photosListBox.takeItem(self.ui.photosListBox.row(item))
			del row
	
	
	def uploadFiles(self):
		if  self._ONLINE == False:
			self._message(u"Nie jesteś zalogowany")
			return

		count = self.ui.photosListBox.count()
		if count > 0:#Na liście są pliki
			host= str(self.ui.hostCB.currentText())
			if host is not None:
				photos=[]
				pack = self.ui.packSizeCB.currentText()
				packSize = pack.toInt()
				self.ui.sendPhotosPB.setDisabled(True)
				for i in range(0, count):
					file = self.ui.photosListBox.item(i).text()
					file = file.toLocal8Bit()
					file=str(file)
					photos.append(file)
				if self.ui.albumType.currentIndex()==0: #istniejący album
					albumID =str(self.ui.albumCB.itemData(self.ui.albumCB.currentIndex()).toString())
					albumName=str(self.ui.albumCB.currentText())	
					send, message = socjum.upload(host,albumID,photos, limit=packSize[0])
				elif self.ui.albumType.currentIndex()==1: #nowy album
					albumName=str(self.ui.newAlbumLE.text())
					canAdd = str(self.ui.whoCanAddCB.currentIndex())
					send, message = socjum.upload(host,'',photos, limit=1000, canAdd=canAdd, albumName=albumName)

				if send is None:
					self._message(message)
					return
			
				send.start()##rozpoczęcie działania wątku
				self.ui.progressBox.add(send, host, albumName, len(photos))##add thread object to object for display progressbar
				self.ui.photosListBox.clear()
				self.ui.sendPhotosPB.setEnabled(True)

	
	def closeEvent(self, event):
		if self.zamknij() and self.ui.progressBox.abort():
			event.accept()
		else:
			self._message(u"Kończenie wątków zakończone niepowodzenim, spróbuj ponownie")
			event.ignore()
	
	class myPB(QtGui.QGroupBox):#
		def __init__(self):
			QtGui.QGroupBox.__init__(self, u"Status wysyłania")
			self.pbs=[]#lista pasków postępu
			self.lay = QtGui.QVBoxLayout() #układ pionowy
			self.setLayout(self.lay) #dodanie układu
		#thread - wątek wysyłający (size, sent, status, infor, running(), stop()
		#albumName - nazwa albumu, o ile podana
		#photos - liczba wysyłanych zdjęć
		def add(self,thread, host, albumName, photos):
			vLay = QtGui.QVBoxLayout()#layout na etykietę oraz layout paska postępu i przycisków
			hLay = QtGui.QHBoxLayout()#layout na pasek i przycisk kasowania	
			box = QtGui.QGroupBox()
			box.setLayout(vLay)
		
			title = u"Wysyłanie %s zdjęć do albumu %s na %s (Części: %s)" % (photos,albumName, host, thread.packs)
			infoLabel = QtGui.QLabel()
			bar = QtGui.QProgressBar()
			
			cButton = QtGui.QPushButton(QtGui.QIcon(QtGui.QPixmap(':/icons/icons/error.png')), '')
			cButton.setToolTip(u"Anuluj/Usuń zadanie")
			cButton.connect(cButton, QtCore.SIGNAL('clicked()'), thread.stop)
			cButton.connect(cButton, QtCore.SIGNAL('clicked()'), box, QtCore.SLOT('close()'))
			
			bar.setToolTip(title)
			vLay.addLayout(hLay)
			self.lay.addWidget(box)
			hLay.addWidget(bar)
			hLay.addWidget(infoLabel)
			hLay.addWidget(cButton)
			#dodanie wątku, paska i statusu do listy
			self.pbs.append([thread, bar, infoLabel]) 	
			
		def check(self):
			for thread, bar, info in self.pbs:
				if thread.status == 1:
					info.setText(u"Wysłano część %s z %s." % (thread.part, thread.packs) )
				if thread.status ==3: #Miniatury
					info.setText(u"Tworzenie miniatur część %s z %s." % (thread.part, thread.packs) )
					bar.setRange(0,0)
					bar.setValue(1)
				if thread.status == 4:
					info.setText(u"Wysyłanie %s z %s." % (thread.part, thread.packs) )
					bar.setRange(0,thread.size)
					bar.setValue(thread.sent)
				if thread.status ==2:
					self._message(thread.info)
					info.setText(thread.info)
				
		def abort(self):
			for thread, bar, info in self.pbs:
				thread.stop()
			return True
		
	def thumbPixmap(self,url):
		if url.startswith('http://'):
			m=hashlib.md5()
			m.update(url)
			key=m.hexdigest()
			pix = QtGui.QPixmap()
			if not self.thumbnailCache.find(key, pix):
				img = urllib.urlopen(url)
				pix.loadFromData(img.read())
				self.thumbnailCache.insert(key, pix)
			return pix	

		else:
			return QtGui.QPixmap(url)

	
	def __init__(self, parent=None ):  
			QtGui.QWidget.__init__(self, parent)
			self.ui=PySoQtWin.Ui_PySoQtWin()
			self.ui.setupUi(self)
			self._ONLINE = False
			self.thumbnailCache = QtGui.QPixmapCache()#cache w pamięci na miniatury albumów
			#ustawienie akcji logowania
			self.ui.loginPB.connect(self.ui.loginPB, QtCore.SIGNAL('clicked()'), self.login)
			self.ui.passwordLE.connect(self.ui.passwordLE,QtCore.SIGNAL("returnPressed()"), self.login)
			#ustawienie akcji wylogowania
			self.ui.logoutTB.connect(self.ui.logoutTB, QtCore.SIGNAL('triggered()'),self.logout)
			#dodanie boxu na paski postępu pobierania
			self.ui.progressBox = self.myPB()
			self.ui.mainLayout.insertWidget(3,self.ui.progressBox)
			#przeładowanie informacji o albumach
			self.ui.hostReloadPB.connect(self.ui.hostReloadPB, QtCore.SIGNAL('clicked()'), self.reloadAlbums)
			#wybór zjdęć
			self.ui.selectPhotosPB.connect(self.ui.selectPhotosPB, QtCore.SIGNAL('clicked()'), self.getFiles)
			#kasowani zaznaczonych zdjęć
			self.ui.deleteSelectedPB.connect(self.ui.deleteSelectedPB, QtCore.SIGNAL('clicked()'),self.deleteSelectedFiles)
			#wysyłanie zdjęć
			self.ui.sendPhotosPB.connect(self.ui.sendPhotosPB, QtCore.SIGNAL('clicked()'),self.uploadFiles)
			#sprawdzenie aktualnego taba do wysyłki
			self.ui.albumType.connect(self.ui.albumType, QtCore.SIGNAL('currentChanged(int)'), self.checkAlbumType)
			
if __name__ == '__main__':
	socjum = Socjum()
	app =QtGui.QApplication(sys.argv)
	win = Win()
	win.show()
	sys.exit(app.exec_())  
